/*
 * clase utilizada para realizar metodos compartivos de toda tipo de varialbes
 * 
 */

package clases;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.hibernate.Transaction;
import tablas.Cliente;
import tablas.Empleado;
/**
 *
 * @author ad
 */
public class Comparacion {
    private File ArchivodeCompensacion;
    private BufferedReader bufer_lectura; //buffer lector
    private OutputStreamWriter bufer_escritura; //buffer lector
    public String archivoEncurso=null;
    /***
     * variable usada en el serlet grabador para identificar la ruta del archivo subido
     ***/
    private String direccion="";


    //-------------------------------------------------------------------------------------------------------------
    /***esto es el archivo de resultado de que se utilizara para mostrar los datos de las compensacions***/
    File archivoResultado;
    private OutputStreamWriter bufer_escrituraRESULTADO; //buffer lector

    File archivoLOG;
    private OutputStreamWriter bufer_escrituraLOG; //buffer lector

    /***
     * verifica que tipo de usuario se va a insertar en la base de datos
     * por medio de hibernate
     * los operador y gerente se toman de la misma forma ya que es un empleado
     * de la empresa
     *....cliente
     * ...empleado
     **/
    public String tipo_de_usuario_insercion_modelo(String[] matris) {

        if (matris[0] != null) {//cliente
            return "cliente";
        } else if (matris[1] != null) {//operador
            return "empleado";
        } else if (matris[2] != null) {//es gerente
            return "empleado";
        } else if (matris[3] != null) {
            return null;
        }
        return null;
    }


     public boolean verificarrolAsignadoGerente(String[] matris) {
        boolean k = true;//retorna true si es gerente
        if (matris[0] != null) {//cliente
            return false;
        } else if (matris[1] != null) {//operador
            return false;
        } else if (matris[2] != null) {//es gerente
            //como es gerente puede eliminar al usuario entonces agregamos perimisos de sysadmin
            return true;
        } else if (matris[3] != null) {
            return false;
        }
        return k;
    }

     /****
      * verificar que tipo de cliente es y asi lo asignamos
      ****/
    Cliente asignardatoscliente( Cliente micliente, Tipo[] param) {

        for (int i = 0; i < param.length; i++) {
            Tipo tipo = param[i];

                if(tipo.gettipo().compareTo("nombre")==0)
                    micliente.setNombre(tipo.getvalor());
                else if(tipo.gettipo().compareTo("direccion")==0)
                    micliente.setDireccion(tipo.getvalor());
                else if(tipo.gettipo().compareTo("tipo")==0)
                    micliente.setTipo(tipo.getvalor());
                else if(tipo.gettipo().compareTo("foto")==0)
                    micliente.setFoto(tipo.getvalor());
                else if(tipo.gettipo().compareTo("firma")==0)
                    micliente.setFirma(tipo.getvalor());
                else if(tipo.gettipo().compareTo("tipocliente")==0)
                {
                    if(tipo.getvalor().compareTo("individual")==0)
                    micliente.setIsIndividual(new Byte("1"));
                    else
                    micliente.setIsIndividual(new Byte("0"));
                }else if(tipo.gettipo().compareTo("mail")==0)
                    micliente.setMail(tipo.getvalor());
                else if(tipo.gettipo().compareTo("telefono")==0)
                    micliente.setTelefono(tipo.getvalor());
                else if(tipo.gettipo().compareTo("nit")==0)
                    micliente.setIdCliente(Integer.parseInt(tipo.getvalor().replace("-","")));
            }

        return micliente;
    }

    Empleado asignardatosempleado(Empleado miempleado, Tipo[] param) {
        for (int i = 0; i < param.length; i++) {
            Tipo tipo = param[i];
             if(tipo.gettipo().compareTo("nombre")==0)
                    miempleado.setNombre(tipo.getvalor());
                else if(tipo.gettipo().compareTo("direccion")==0)
                    miempleado.setDireccion(tipo.getvalor());
                else if(tipo.gettipo().compareTo("mail")==0)
                    miempleado.setMail(tipo.getvalor());
                else if(tipo.gettipo().compareTo("telefono")==0)
                    miempleado.setTelefono(tipo.getvalor());
                else if(tipo.gettipo().compareTo("nit")==0)
                 miempleado.setIdEmpleado(Integer.parseInt(tipo.getvalor().replace("-","")));
                else if(tipo.gettipo().compareTo("departamento")==0)
                {
                   miempleado.setDepartamentoIdDepartamento(Integer.parseInt(tipo.getvalor()));
                }else if (tipo.gettipo().compareTo("sucursal") == 0)
                {
                    Conexion xs=new Conexion();
                    miempleado.setSucursal(xs.reg_sucursal_id(tipo.getvalor()));
                }

                
        }


        return miempleado;
    }


    /***
     * regresa un label y una caja de texto
     ***/
    public String regresarEtiquetaHTML(String valor,String tipo)
    {
        String k="";
        if(tipo.compareTo("foto")!=0&&tipo.compareTo("firma")!=0)
         {
         k="<li><label>"+tipo+
                   "<input name=\""+tipo+"\" "+
                   "type=\"text\" size=32 value=\""+valor+"\" />"+
                   "</label></li>";
         }else{//si es firma y foto
                   k="<li><label>"+tipo+
                   "<input name=\""+tipo+"\" "+
                   "type=\"text\" size=32 value=\""+valor+"\" />"+
                   "</label></li>"+
                   "<li><label> Nueva "+tipo+
                   "<input name=\""+tipo+"1\" "+
                   "type=\"file\" size=32  />"+
                   "</label></li>";
         }
         return k;

    }

  /*  private int regresaDepartamento_id(String valor) {
        Conexion nueva=new Conexion();
        return nueva.regrasarDepartamento_Objeto_id(valor);
    }*/



    //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------METODOS DE GRABADOR--------------------------------------------------------------------------------------    //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------

    /***
     * abre el archivo de compensacion para carga el archivo
     * nombre=ruta y nombre del archivo
     * escritura=true entoces se abrira el buffer de escritura si no en su defecto
     * sera el bufer_lectura.
     * retorna true si se abrio y false de lo contrario
     ***/

    public boolean AbrirArchivo_Compensacion(String nombre,boolean escritura)
    {
       ArchivodeCompensacion = new File(nombre);
       if(escritura==false)
       {
            try {
                bufer_lectura = new BufferedReader(new InputStreamReader(new FileInputStream(nombre)));
            } catch (FileNotFoundException ex) {
                System.out.println(ex.getMessage());
                return false;
            }
       }else
       {
            try {
                bufer_escritura = new OutputStreamWriter(new FileOutputStream(ArchivodeCompensacion));
            } catch (FileNotFoundException ex) {
                System.out.println(ex.getMessage());
                return false;
            }

       }
       return true;
    }

    /***
     * cierra el archivo de compensacion si
     * escritura=true entoces se cerrara el buffer de escritura si no en su defecto
     * sera el archivo de bufer_lectura.
     **/
    public void CerrarArchivo(boolean escritura)
    {
       if(escritura)
            try {
            bufer_escritura.close();
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
           else
            try {
            bufer_lectura.close();
        } catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
    }

    /***
     * regresa un dato de la linea de archivo de compensacion
     ***/
    public String devolverDatoCompensacion()
    {
        try {
            String dato = null;
            dato = bufer_lectura.readLine();
            return dato;
        }
        //-------------------------------------------------------------------------------------------------------------------------------------------------
            catch (IOException ex) {
            System.out.println(ex.getMessage());
            return null;
        }
    }

    /***
     * metodo el cual abre el archivo y procesa todos la peticiones de cuentas para compensar
     * el cual se mira el numero de cheque y si fue o no compensado con exito
     * trae numero de cheque y estado
     * orden de parametros
     * numero de cheque
     * resultado de la compnesacion
     * numero de cuenta
     * numero de chequera
     *
     ***/
    public boolean procesoCompensacion(String empleadolog,String direccion)
    {
       
        Conexion nueva=new Conexion();

        boolean abrir=AbrirArchivo_Compensacion(direccion,false);
        try{

        //ELIMINAMOS LA PRIMERA LINEA
        devolverDatoCompensacion();
        //primera linea valida
        String data=devolverDatoCompensacion();

        while(data!=null)
        {

           boolean res=false;
                   if(data!=null){
                       String[] datos=data.split(",");
                       //realizar la operacion para validar el proceso
                       int numero_cheque=Integer.parseInt(datos[0]);
                       int cuenta=Integer.parseInt(datos[2]);
                       int numerochequera=Integer.parseInt(datos[3]);
                       String resultado=datos[1];
                       res=nueva.actualizarTransaccionCuenta_OperacionTransaccion(resultado,numero_cheque,cuenta,numerochequera);
                   }

                   //obtenemos la siguiente linea
                   data=devolverDatoCompensacion();
                   //regresamos al while para seguir procesando datos

        }

        

        }
        catch(Exception qs)
        {
            System.out.println("ocurrio un error"+qs.getMessage());
            return false;
            
        }finally{

            if(abrir)
            CerrarArchivo(false);
        }
        return true;
    }

    /***
     * para  compesar.....
     * numeros cheque
     * valor
     * numero cuenta
     * numero chequera
     ****/
   public boolean procesoCompensacionCheques(String empleadolog,String direccion)
    {
        //abrimos el archivo si
        boolean abrir=AbrirArchivo_Compensacion(direccion,false);
        boolean retornar=true;

        //no se pudo abrir el archivo
        if(abrir==false)
            return false;//salimos inmediatamente del metodo

        try{
        //ELIMINAMOS LA PRIMERA LINEA
        devolverDatoCompensacion();
        //primera linea valida
        String data=devolverDatoCompensacion();
        //una transaccion global
        Conexion nueva=new Conexion();
        AbrirYlimpiarArchivoRESULTADO();
        
        while(data!=null)
        {
          
            String[] datos=data.split(",");

                      //buscar el numero de cheque,valor,cuenta
                      int numero_cheque=Integer.parseInt(datos[0]);
                      double valor=Double.parseDouble(datos[1]);
                      int cuenta=Integer.parseInt(datos[2]);
                      int numero_chequera=Integer.parseInt(datos[3]);


                     try{
                              boolean n =  nueva.ChequePropio(empleadolog,numero_chequera,numero_cheque, valor,cuenta);

                              if(n==true)
                              {
                                 //fue exitoso
                                 //escribimos en log y en nuestro archivo

                                 //escribimos en el archivo de resultado
                                 AgregarDatosdecompensacionArchivoResultado(numero_cheque,"aceptado",cuenta,numero_chequera);
                              }
                              else
                              {
                                 //no fue exitoso escribimos en el log
                                  
                                 //escribimos en el archivo de resultado
                                 AgregarDatosdecompensacionArchivoResultado(numero_cheque,"negado",cuenta,numero_chequera);
                              }

                    }catch(Exception xs)
                    {
                        System.out.println(xs.getMessage());
                        retornar=false;
                    }
                                                   
           
          data = devolverDatoCompensacion();
        }



        }
        catch(Exception q)
        {
           System.out.println("ocurrio un error"+q.getMessage());
           retornar=false;

        }finally{

                try {

                    if (abrir) {
                        CerrarArchivo(false);
                    }

                    bufer_escrituraRESULTADO.close();
                    bufer_escrituraLOG.close();
                } catch (IOException ex) {
                   System.out.println(ex.getMessage());
                }

        }
        
        return retornar;
    }



    public void EscribirArchivo(String dato)
    {
        try {
            bufer_escritura.write(dato);
            bufer_escritura.flush();
        }
            catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
    }


     public int subirArchivosdeTexto(HttpServletRequest request) {
            int retorno =0;
            FileItemFactory file_factory = new DiskFileItemFactory();
            Querys nus=new Querys();
            String rutaAbsoluta_imagenes=nus.rutaAbsoluta_imagenes;

            /*ServletFileUpload esta clase convierte los input file a FileItem*/
            ServletFileUpload servlet_up = new ServletFileUpload(file_factory);
            
            try{
            /*sacando los FileItem del ServletFileUpload en una lista */
            List items = servlet_up.parseRequest(request);
            for(int i=0;i<items.size();i++){
             /*FileItem representa un archivo en memoria que puede ser pasado al disco duro*/
             FileItem item = (FileItem) items.get(i);
             /*item.isFormField() false=input file; true=text field*/

                     //no trae nombre el archivo el campo esta en blanco
                     if(item.getName()==null || item.getName().equals(""))
                         return 0;


             if (! item.isFormField()){
                /*cual sera la ruta al archivo en el servidor*/
                 String ruta="";
                 if(item.getFieldName().compareTo("compensacion")==0)
                 {
                     ruta = rutaAbsoluta_imagenes + item.getName();
                     archivoEncurso=item.getName();
                     retorno=1;
                 }
                 else if(item.getFieldName().compareTo("cheque_compensado")==0)
                 {
                     ruta = rutaAbsoluta_imagenes + item.getName();
                     archivoEncurso=item.getName();
                     retorno=2;
                 }

                
                 File archivo_server = new File(ruta);
                 direccion=item.getName();
                 /*y lo escribimos en el servido*/
                 item.write(archivo_server);
                

             }

         }}catch(Exception xss)
         {
             System.out.println("Error en el metodo subirArchivo de texto"+xss.getMessage());
             retorno=0;
         }
            return retorno;
    }

     /***
      * metodo q muestra la ruta completa del archivo que se acaba de cargar
      ***/
    public String regresarnombreTotalArchivosubido() {
       return direccion;
    }





    //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------
        //-------------------------------------------------------------------------------------------------------------------------------------------------
    //-------------------------------------------------------------------------------------------------------------------------------------------------

    //ESTOS METODOS SON PARA MANEJAR EL ARCHIVO LOG
     private void abrirArchivoLog()
     {
        Querys nuevos=new Querys();
        String rutas=nuevos.rutaAbsoluta_LOG;
        archivoResultado=new File(rutas);

            //abrimos el bufer de escritura del archivo
            try{
                bufer_escrituraLOG = new OutputStreamWriter(new FileOutputStream(archivoLOG));
               
            } catch (FileNotFoundException ex) {
                System.out.println(ex.getMessage());
            }
     }

     public void EscribirDatosLog(String mensaje)
     {
        abrirArchivoLog();
     }

      private void EscribirLOG(String dato)
    {
        try {
            bufer_escrituraLOG.write(dato);
            bufer_escrituraLOG.flush();
        }
            catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
    }


    /****
      * escribira el archivo de resultado de las compensaciones que fueron realizadoas...
    ***/
    private void AgregarDatosdecompensacionArchivoResultado(int numero_cheque, String string, int cuenta, int numero_chequera) {
        String dato=numero_cheque+","+string+","+cuenta+","+numero_chequera;
        EscribirRESULTADO(dato);
    }

    /***
     abre y limpia el archivo de resultados
     ***/
    private void AbrirYlimpiarArchivoRESULTADO() {
        //creamos el nuevo archivo
        Querys nuevos=new Querys();
        String rutas=nuevos.rutaAbsoluta_imagenes+"RESULTADO.txt";
        archivoResultado=new File(rutas);

            //abrimos el bufer de escritura del archivo
            try{
                bufer_escrituraRESULTADO = new OutputStreamWriter(new FileOutputStream(archivoResultado));
                EscribirRESULTADO("#CHEQUE,RESULTADO,#CUENTA,#CHEQUERA");//primera linea de encabezado
            } catch (FileNotFoundException ex) {
                System.out.println(ex.getMessage());
            }

       }
    /***
     * escribe finalmente el dato en el archivo
     ***/
     private void EscribirRESULTADO(String dato)
    {
        try {
            bufer_escrituraRESULTADO.write(dato);
            bufer_escrituraRESULTADO.flush();
        }
            catch (IOException ex) {
            System.out.println(ex.getMessage());
        }
    }








}
